// 1. 封装Event类， 实现事件 绑定， 触发， 解除。
interface EventListRawState {
  click?: Function[];
  [propsName: string]: Function[];
}

interface ParamsState {
  [propsName: string]: any;
}

/******
 *
 *
 *
 */

export class MyEvent {
  eventList: EventListRawState = {};
  // 绑定事件
  on(type: string, callback: Function) {
    // 判断事件是否存在
    if (this.eventList[type] === undefined) {
      // 不存在该事件
      this.eventList[type] = [callback];
    } else {
      // 存在该事件
      this.eventList[type].push(callback);
    }
  }
  // 触发事件
  emit(type: string, params?: ParamsState) {
    if (this.eventList[type] !== undefined) {
      this.eventList[type].forEach((callback) => {
        callback(params);
      });
    }
  }
  // 解除事件
  off(type: string) {
    delete this.eventList[type];
  }
}

// 2. 封装Storage 类， 提供本地存储和会话存储的操作。

export class MyStoreage {
  storage: Storage = localStorage;
  // 设置
  setItem(key: string, value: any) {
    if (typeof value === "string") {
      this.storage.setItem(key, value);
    } else if (
      typeof value === "bigint" ||
      typeof value === "number" ||
      typeof value === "boolean" ||
      typeof value === "symbol"
    ) {
      this.storage.setItem(key, value.toString());
    } else if (typeof value === "object" && value !== null) {
      this.storage.setItem(key, JSON.stringify(value));
    }
  }
  // 获取
  getItem(key: string) {
    try {
      // 尝试执行
      return JSON.parse(localStorage.getItem(key));
    } catch {
      // 发生问题
      return localStorage.getItem(key);
    }
  }
  // 移动
  removeItem() {}
  // 清空
  clear() {}
}

// localStorage.
// sessionStorage

// 该函数接收两个参数分别为旧版本、新版本，当新版本高于旧版本时表明需要更新，返回true，否则返回false。
// 注意：
// 1. 版本号格式均为"X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X.X"
// 2. X∈[0,9]
// 3. 当两个版本号相同时，不需要更新

class Day4 {
  static _shouldUpdate(
    oldVersion: /*老版本*/ string,
    newVersion: /*新版本*/ string
  ): boolean {
    // 方式一:
    // const [a, b, c] = oldVersion.split(".");
    // const [d, e, f] = newVersion.split(".");

    // if (+a === +d) {
    //   if (+b === +e) {
    //     return +c < +f;
    //   } else {
    //     return +b < +e;
    //   }
    // } else {
    //   return +a < +d;
    // }

    // 方式二：
    const oddArr = oldVersion.split(".").map((v) => +v);
    const newArr = newVersion.split(".").map((v) => +v);

    const result = oddArr.every((v, i) => v === newArr[i]);
    if (result) {
      return false;
    }
    return true;
  }

  static _findRepeatNumber(arr: number[]): number[] {
    const result: number[] = []
    arr.forEach((num) => {
      if (/*两次*/ arr.indexOf(num) !== arr.lastIndexOf(num)) {
        result.push(num)
      }
    });

    return Array.from(new Set(result));
  }
}

const s1 = Day4._shouldUpdate("1.2.3", "4.5.6");
const s2 = Day4._shouldUpdate("6.2.3", "4.5.6");
const s3 = Day4._shouldUpdate("4.5.3", "4.5.6");
const s4 = Day4._shouldUpdate("4.5.6", "4.5.6");
const s5 = Day4._findRepeatNumber([1, 1, 2, 2, 3, 3, 4, 5, 6]);
console.log(s5)
export class Stack<T> {
  state: T[] = [];
  // 入栈
  push(value: T) {
    this.state.push(value);
    return this.state.length;
  }
  // 出栈
  pop() {
    return this.state.pop();
  }
  // 封装获取数据的方法
  splice(index: /* 从哪里开始取 */ number, len: number = 1, newArr: T[] = []) {
    // 共需要出栈几次才可以拿到想要的数据
    const subLen = this.state.length - index;
    // 临时存储容器--出栈临时数据
    const box = [];
    // 取出临时数据
    for (let i = 1; i <= subLen; i++) {
      const value = this.state.pop();
      box.unshift(value);
    }
    const result = [];
    // 获取指定数据
    for (let i = 0; i < len; i++) {
      result.push(box.shift());
    }
    // 先插入新数据
    newArr.forEach((v) => this.state.push(v));
    // 放回去临时数据
    box.forEach((v) => this.state.push(v));

    return result;
  }
}

const ss = new Stack<string | number>();

ss.push("a");
ss.push("b");
ss.push("c");
ss.push("d");
ss.push("e");
ss.push("f");
ss.push("g");
// [1,2,3]
ss.push("h");
ss.push("i");

// ss.push("f");
// ss.push("g");

const d = ss.splice(5, 2, [1, 2, 3]);
console.log(d, ss);
